home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MultiDesktop.lha / MultiDesktop / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  42.4 KB  |  1,932 lines
  1. /* Menüs */
  2. #include "multiwindows.h"
  3.  
  4. extern struct ExecBase         *SysBase;
  5. extern struct MultiWindowsBase *MultiWindowsBase;
  6. extern struct MultiDesktopBase *MultiDesktopBase;
  7.  
  8. void GetCommand();
  9. void SysItemHandler();
  10. void MasterItem();
  11. void CallItemAction();
  12.  
  13. /* ---- Menüpunkt wurde ausgewählt */
  14. void MenuPick(we,msg,mm)
  15.  struct WindowEntry  *we;
  16.  struct IntuiMessage *msg;
  17.  struct MultiMessage *mm;
  18. {
  19.  UWORD              code;
  20.  struct MWMenuItem *item;
  21.  
  22.  we->MenuInUse=FALSE;
  23.  MenuHelpClose(we);
  24.  mm->Class=MULTI_MENUPICK;
  25.  code=msg->Code;
  26.  
  27.  item=ItemAddress(we->FirstMenu,code);
  28.  if(item==NULL) return;
  29.  if(item->Flags & CMI_BARITEM) return;
  30.  
  31.  mm->Class=MULTI_MENUPICK;
  32.  mm->ObjectID=item->ItemID;
  33.  mm->ObjectAddress=item;
  34.  if(item->MenuItem.Flags & CHECKED) mm->ObjectCode=TRUE;
  35.  
  36.  if(item->ItemAction)
  37.   { 
  38.    if((we->MenuOn)&&(!we->Iconify))
  39.      ClearMenuStrip(we->Window);
  40.    CallItemAction(we,item);
  41.    if((we->MenuOn)&&(!we->Iconify))
  42.      SetMenuStrip(we->Window,we->FirstMenu);
  43.   }
  44.  
  45.  SysItemHandler(item);
  46. }
  47.  
  48. /* ---- System-Item-Behandlung */
  49. void SysItemHandler(item)
  50.  struct MWMenuItem *item;
  51. {
  52.  
  53.  if(item->Flags & CMI_SYSITEM)
  54.   {
  55.    switch(item->ItemID)
  56.     {
  57.      case STDITEM_ONLINEHELP:
  58.        if(item->MenuItem.Flags & CHECKED) HelpOn(); else HelpOff();
  59.       break;
  60.      case STDITEM_LOADGUIDE:
  61.       break;
  62.      case STDITEM_ABOUTHELP:
  63.       break;
  64.      case STDITEM_DEVELOPER:
  65.        if(item->MenuItem.Flags & CHECKED) DeveloperOn(); else DeveloperOff();
  66.       break;
  67.     }
  68.    return;
  69.   }
  70. }
  71.  
  72. /* ---- Menüauswahl vorbereiten */
  73. void MenuVerify(we)
  74.  struct WindowEntry *we;
  75. {
  76.  we->MenuInUse=TRUE;
  77.  GadHelpClose(we);
  78.  MenuHelpOpen(we);
  79. }
  80.  
  81. /* ---- Länge eines Textes in Pixeln ermitteln */
  82. UWORD PixelLength(font,text)
  83.  struct TextFont    *font;
  84.  UBYTE              *text;
  85. {
  86.  struct RastPort rp;
  87.  
  88.  InitRastPort(&rp);
  89.  SetFont(&rp,font);
  90.  return(TextLength(&rp,text,strlen(text)));
  91. }
  92.  
  93. /* ---- we->Last... updaten  */
  94. void UpdateLast(we)
  95.  struct WindowEntry *we;
  96. {
  97.  struct MWMenu      *menu;
  98.  struct MWMenuItem  *item;
  99.  struct MWMenuItem  *sub;
  100.  
  101.  WE;
  102.  if(we==NULL) return;
  103.  
  104.  we->LastMenu=NULL;
  105.  we->LastMenuItem=NULL;
  106.  we->LastSubItem=NULL;
  107.  
  108.  menu=we->FirstMenu;
  109.  while(menu!=NULL)
  110.   {
  111.    we->LastMenu=menu;
  112.    item=menu->Menu.FirstItem;
  113.    while(item!=NULL)
  114.     {
  115.      we->LastMenuItem=item;
  116.      sub=item->MenuItem.SubItem;
  117.      while(sub!=NULL)
  118.       {
  119.        we->LastSubItem=sub;
  120.        sub=sub->MenuItem.NextItem;
  121.       }
  122.      item=item->MenuItem.NextItem;
  123.     }
  124.    menu=menu->Menu.NextMenu;
  125.   }
  126. }
  127.  
  128. /* ---- Menüleiste einschalten */
  129. void ShowMenu()
  130. {
  131.  struct WindowEntry *we;
  132.  
  133.  WE;
  134.  if(we==NULL) return;
  135.  if(we->FirstMenu==NULL) return;
  136.  
  137.  we->MenuOn=TRUE;
  138.  UpdateLast(we);
  139.  
  140.  if(!we->Iconify)
  141.    SetMenuStrip(we->Window,we->FirstMenu);
  142. }
  143.  
  144. /* ---- Menüleiste ausschalten */
  145. void HideMenu()
  146. {
  147.  struct WindowEntry *we;
  148.  
  149.  WE;
  150.  if(we==NULL) return;
  151.  if(we->FirstMenu==NULL) return;
  152.  
  153.  we->MenuOn=FALSE;
  154.  if(!we->Iconify)
  155.    ClearMenuStrip(we->Window);
  156. }
  157.  
  158. /* ---- Menüspeicher freigeben */
  159. void DisposeMenu(we)
  160.  struct WindowEntry *we;
  161. {
  162.  struct MWMenu     *menu,*oldmenu;
  163.  struct MWMenuItem *item,*olditem;
  164.  struct MWMenuItem *sub,*oldsub;
  165.  
  166.  menu=we->FirstMenu;
  167.  while(menu!=NULL)
  168.   {
  169.    item=menu->Menu.FirstItem;
  170.    while(item!=NULL)
  171.     {
  172.      sub=item->MenuItem.SubItem;
  173.      while(sub!=NULL)
  174.       {
  175.        oldsub=sub;
  176.        if(sub->String[0]) FREE2(sub->String[0]);
  177.        if(sub->String[1]) FREE2(sub->String[1]);
  178.        FreeMemory(&sub->Remember);
  179.        FREE2(sub);
  180.        sub=oldsub->MenuItem.NextItem;
  181.       }
  182.      olditem=item;
  183.      if(item->String[0]) FREE2(item->String[0]);
  184.      if(item->String[1]) FREE2(item->String[1]);
  185.      FreeMemory(&item->Remember);
  186.      FREE2(item);
  187.      item=olditem->MenuItem.NextItem;
  188.     }
  189.    oldmenu=menu;
  190.    FREE2(menu);
  191.    menu=oldmenu->Menu.NextMenu;
  192.   }
  193. }
  194.  
  195. /* ---- Menü löschen */
  196. void KillMenu()
  197. {
  198.  struct WindowEntry *we;
  199.  
  200.  WE;
  201.  if(we==NULL) return;
  202.  
  203.  we->LastMenu=NULL;
  204.  we->LastMenuItem=NULL;
  205.  we->LastSubItem=NULL;
  206.  
  207.  if(we->FirstMenu)
  208.   {
  209.    DisposeMenu(we);
  210.    we->FirstMenu=NULL;
  211.    we->MenuOn=FALSE;
  212.    if(!we->Iconify) ClearMenuStrip(we->Window);
  213.   }
  214. }
  215.  
  216. /* ---- Menü suchen */
  217. struct MWMenu *FindMenu(menuID)
  218.  ULONG menuID;
  219. {
  220.  struct WindowEntry *we;
  221.  struct MWMenu      *menu;
  222.  struct MWMenu      *prev;
  223.  
  224.  WE;
  225.  if(we==NULL) return(NULL);
  226.  
  227.  prev=NULL;
  228.  menu=we->FirstMenu;
  229.  while(menu!=NULL)
  230.   {
  231.    if(menu->MenuID==menuID)
  232.     {
  233.      menu->FindPrevMenu=prev;
  234.      return(menu);
  235.     }
  236.    prev=menu;
  237.    menu=menu->Menu.NextMenu;
  238.   }
  239.  return(NULL);
  240. }
  241.  
  242. /* ---- Item suchen */
  243. struct MWMenuItem *FindItem(itemID)
  244.  ULONG itemID;
  245. {
  246.  struct WindowEntry *we;
  247.  struct MWMenu      *menu;
  248.  struct MWMenuItem  *item;
  249.  struct MWMenuItem  *prev;
  250.  
  251.  WE;
  252.  if(we==NULL) return(NULL);
  253.  
  254.  menu=we->FirstMenu;
  255.  while(menu!=NULL)
  256.   {
  257.    prev=NULL;
  258.    item=menu->Menu.FirstItem;
  259.    while(item!=NULL)
  260.     {
  261.      if(item->ItemID==itemID)
  262.       {
  263.        item->FindPrevItem=prev;
  264.        item->FindMenu=menu;
  265.        return(item);
  266.       }
  267.      prev=item;
  268.      item=item->MenuItem.NextItem;
  269.     }
  270.    menu=menu->Menu.NextMenu;
  271.   }
  272.  return(NULL);
  273. }
  274.  
  275. /* ---- Menü oder Item suchen */
  276. struct MWMenuItem *FindMenuOrItem(findID,type)
  277.  ULONG  findID;
  278.  UBYTE *type;
  279. {
  280.  struct WindowEntry *we;
  281.  struct MWMenu      *menu;
  282.  struct MWMenuItem  *item;
  283.  struct MWMenu      *prev;
  284.  struct MWMenuItem  *prevItem;
  285.  
  286.  WE;
  287.  if(we==NULL) return(NULL);
  288.  
  289.  prev=NULL;
  290.  menu=we->FirstMenu;
  291.  while(menu!=NULL)
  292.   {
  293.    if(menu->MenuID==findID)
  294.     {
  295.      menu->FindPrevMenu=menu;
  296.      *type=FINDTYPE_MENU;
  297.      return(menu);
  298.     }
  299.    prevItem=NULL;
  300.    item=menu->Menu.FirstItem;
  301.    while(item!=NULL)
  302.     {
  303.      if(item->ItemID==findID)
  304.       {
  305.        item->FindPrevItem=prevItem;
  306.        item->FindMenu=menu;
  307.        *type=FINDTYPE_ITEM;
  308.        return(item);
  309.       }
  310.      prevItem=item;
  311.      item=item->MenuItem.NextItem;
  312.     }
  313.    prev=menu;
  314.    menu=menu->Menu.NextMenu;
  315.   }
  316.  return(NULL);
  317. }
  318.  
  319. /* ---- Sub-Item suchen */
  320. struct MWMenuItem *FindSubItem(subID)
  321.  ULONG subID;
  322. {
  323.  struct WindowEntry *we;
  324.  struct MWMenu      *menu;
  325.  struct MWMenuItem  *item;
  326.  struct MWMenuItem  *sub;
  327.  struct MWMenuItem  *prev;
  328.  
  329.  WE;
  330.  if(we==NULL) return(NULL);
  331.  
  332.  menu=we->FirstMenu;
  333.  while(menu!=NULL)
  334.   {
  335.    item=menu->Menu.FirstItem;
  336.    while(item!=NULL)
  337.     {
  338.      prev=NULL;
  339.      sub=item->MenuItem.SubItem;
  340.      while(sub!=NULL)
  341.       {
  342.        if(sub->ItemID==subID)
  343.         {
  344.          sub->FindPrevItem=prev;
  345.          sub->FindMenu=menu;
  346.          sub->FindMasterItem=item;
  347.          return(sub);
  348.         }
  349.        prev=item;
  350.        sub=sub->MenuItem.NextItem;
  351.       }
  352.      item=item->MenuItem.NextItem;
  353.     }
  354.    menu=menu->Menu.NextMenu;
  355.   }
  356.  return(NULL);
  357. }
  358.  
  359. /* ---- Item oder Sub-Item suchen */
  360. struct MWMenuItem *FindItemOrSubItem(findID)
  361.  ULONG findID;
  362. {
  363.  struct WindowEntry *we;
  364.  struct MWMenu      *menu;
  365.  struct MWMenuItem  *item;
  366.  struct MWMenuItem  *sub;
  367.  struct MWMenuItem  *prev,*prevSub;
  368.  
  369.  WE;
  370.  if(we==NULL) return(NULL);
  371.  
  372.  menu=we->FirstMenu;
  373.  while(menu!=NULL)
  374.   {
  375.    item=menu->Menu.FirstItem;
  376.    prev=NULL;
  377.    while(item!=NULL)
  378.     {
  379.      if(item->ItemID==findID)
  380.       {
  381.        item->FindPrevItem=prev;
  382.        item->FindMenu=menu;
  383.        item->FindMasterItem=NULL;
  384.        return(item);
  385.       }
  386.     prevSub=NULL;
  387.     sub=item->MenuItem.SubItem;
  388.      while(sub!=NULL)
  389.       {
  390.        if(sub->ItemID==findID)
  391.         {
  392.          sub->FindPrevItem=prevSub;
  393.          sub->FindMenu=menu;
  394.          sub->FindMasterItem=item;
  395.          return(sub);
  396.         }
  397.        prevSub=sub;
  398.        sub=sub->MenuItem.NextItem;
  399.       }
  400.      prev=item;
  401.      item=item->MenuItem.NextItem;
  402.     }
  403.    menu=menu->Menu.NextMenu;
  404.   }
  405.  return(NULL);
  406. }
  407.  
  408. /* ---- Menü entfernen */
  409. void RemMenu(menuID)
  410.  ULONG menuID;
  411. {
  412.  struct WindowEntry *we;
  413.  struct MWMenu      *menu,*next;
  414.  WORD                width;
  415.  
  416.  WE;
  417.  if(we==NULL) return;
  418.  
  419.  menu=FindMenu(menuID);
  420.  if(menu==NULL) return;
  421.  
  422.  if((we->MenuOn)&&(!we->Iconify))
  423.    ClearMenuStrip(we->Window);
  424.  
  425.  /* ---- Menü aus Liste entfernen ----------------------------- */
  426.  
  427.  if(menu->FindPrevMenu)
  428.    menu->FindPrevMenu->Menu.NextMenu=menu->Menu.NextMenu;
  429.  else
  430.    we->FirstMenu=menu->Menu.NextMenu;
  431.  
  432.  next=menu->Menu.NextMenu;
  433.  width=menu->Menu.Width;
  434.  FREE2(menu);
  435.  
  436.  /* ---- Folgende Menüs korrigieren --------------------------- */
  437.  while(next!=NULL)
  438.   {
  439.    next->Menu.LeftEdge-=width;
  440.    next->NextLeftEdge-=width;
  441.    next=next->Menu.NextMenu;
  442.   }
  443.  
  444.  UpdateLast(we);
  445.  
  446.  if((we->MenuOn)&&(!we->Iconify))
  447.    SetMenuStrip(we->Window,we->FirstMenu);
  448. }
  449.  
  450. /* ---- Menü disablen */
  451. void DisableMenu(menuID)
  452.  ULONG menuID;
  453. {
  454.  struct WindowEntry *we;
  455.  struct MWMenu      *menu;
  456.  
  457.  WE;
  458.  if(we==NULL) return;
  459.  menu=FindMenu(menuID);
  460.  if(menu==NULL) return;
  461.  
  462.  
  463.  if((we->MenuOn)&&(!we->Iconify))
  464.    ClearMenuStrip(we->Window);
  465.  
  466.  menu->Menu.Flags &= ~MENUENABLED;
  467.  
  468.  if((we->MenuOn)&&(!we->Iconify))
  469.    SetMenuStrip(we->Window,we->FirstMenu);
  470. }
  471.  
  472. /* ---- Menü enablen */
  473. void EnableMenu(menuID)
  474.  ULONG menuID;
  475. {
  476.  struct WindowEntry *we;
  477.  struct MWMenu      *menu;
  478.  
  479.  WE;
  480.  if(we==NULL) return;
  481.  menu=FindMenu(menuID);
  482.  if(menu==NULL) return;
  483.  
  484.  
  485.  if((we->MenuOn)&&(!we->Iconify))
  486.    ClearMenuStrip(we->Window);
  487.  
  488.  menu->Menu.Flags |= MENUENABLED;
  489.  
  490.  if((we->MenuOn)&&(!we->Iconify))
  491.    SetMenuStrip(we->Window,we->FirstMenu);
  492. }
  493.  
  494. /* ---- Menü initialisieren */
  495. struct MWMenu *InitMenu(we,menuID,helpID,textID,flags)
  496.  struct WindowEntry *we;
  497.  ULONG menuID;
  498.  ULONG helpID;
  499.  ULONG textID;
  500.  UWORD flags;
  501. {
  502.  UBYTE                   *text;
  503.  struct MultiWindowsUser *mw;
  504.  struct MWMenu           *menu;
  505.  
  506.  USER;
  507.  menu=ALLOC2(sizeof(struct MWMenu));
  508.  if(menu==NULL) { NoMemory(); return(NULL); }
  509.  
  510.  text=FindID(mw->Catalog,textID);
  511.  menu->Menu.TopEdge=0;
  512.  menu->Menu.Width=PixelLength(we->Screen->RastPort.Font,text)+10;
  513.  menu->Menu.Height=mw->TextFont->tf_YSize;
  514.  if(!(flags & CME_DISABLE)) menu->Menu.Flags=MENUENABLED;
  515.  menu->Menu.MenuName=text;
  516.  
  517.  menu->MenuID=menuID;
  518.  menu->TextID=textID;
  519.  menu->HelpID=helpID;
  520.  menu->Flags=flags;
  521.  
  522.  return(menu);
  523. }
  524.  
  525. /* ---- Menü hinzufügen */
  526. BOOL AddMenu(menuID,helpID,textID,flags)
  527.  ULONG menuID;
  528.  ULONG helpID;
  529.  ULONG textID;
  530.  UWORD flags;
  531. {
  532.  struct MultiWindowsUser *mw;
  533.  struct WindowEntry      *we;
  534.  struct MWMenu           *menu,*prev;
  535.  
  536.  USER;
  537.  WE;
  538.  if(we==NULL) return(FALSE);
  539.  
  540.  menu=InitMenu(we,menuID,helpID,textID,flags);
  541.  if(menu==NULL) return(FALSE);
  542.  
  543.  if((we->MenuOn)&&(!we->Iconify))
  544.    ClearMenuStrip(we->Window);
  545.  
  546.  /* ---- Menüstruktur einrichten ------------- */
  547.  prev=we->LastMenu;
  548.  if(prev!=NULL)
  549.    menu->Menu.LeftEdge=prev->NextLeftEdge;
  550.  else
  551.    menu->Menu.LeftEdge=5;
  552.  menu->NextLeftEdge=menu->Menu.LeftEdge+menu->Menu.Width;
  553.  
  554.  /* ---- Menü an Liste anfügen --------------- */
  555.  if(prev!=NULL)
  556.    prev->Menu.NextMenu=menu;
  557.  else
  558.    we->FirstMenu=menu;
  559.  
  560.  we->LastMenu=menu;
  561.  we->LastMenuItem=NULL;
  562.  we->LastSubItem=NULL;
  563.  
  564.  if((we->MenuOn)&&(!we->Iconify))
  565.   SetMenuStrip(we->Window,we->FirstMenu);
  566.  
  567.  return(TRUE);
  568. }
  569.  
  570. BOOL InsertMenu(prevID,menuID,helpID,textID,flags)
  571.  ULONG prevID;
  572.  ULONG menuID;
  573.  ULONG helpID;
  574.  ULONG textID;
  575.  UWORD flags;
  576. {
  577.  struct MultiWindowsUser *mw;
  578.  struct WindowEntry      *we;
  579.  struct MWMenu           *menu,*prev;
  580.  WORD                     width;
  581.  
  582.  USER;
  583.  WE;
  584.  if(we==NULL) return(FALSE);
  585.  
  586.  /* ---- Menü initialisieren ------------------------- */
  587.  if(prevID==INSERTID_HEAD)
  588.    prev=NULL;
  589.  else if(prevID==INSERTID_TAIL)
  590.   {
  591.    prev=we->FirstMenu;
  592.    if(prev!=NULL)
  593.     { while(prev->Menu.NextMenu!=NULL) prev=prev->Menu.NextMenu; }
  594.   }
  595.  else
  596.   {
  597.    prev=FindMenu(prevID);
  598.    if(prev==NULL) return(FALSE);
  599.   }
  600.  
  601.  menu=InitMenu(we,menuID,helpID,textID,flags);
  602.  if(menu==NULL) return(FALSE);
  603.  
  604.  /* ---- Menü in Liste einfügen ---------------------- */
  605.  
  606.  if((we->MenuOn)&&(!we->Iconify))
  607.    ClearMenuStrip(we->Window);
  608.  
  609.  if(prev)
  610.   {
  611.    menu->Menu.LeftEdge=prev->NextLeftEdge;
  612.    menu->Menu.NextMenu=prev->Menu.NextMenu;
  613.    prev->Menu.NextMenu=menu;
  614.   }
  615.  else
  616.   {
  617.    menu->Menu.LeftEdge=5;
  618.    menu->Menu.NextMenu=we->FirstMenu;
  619.    we->FirstMenu=menu;
  620.   }
  621.  width=menu->Menu.Width;
  622.  menu->NextLeftEdge=menu->Menu.LeftEdge+width;
  623.  
  624.  /* ---- Folgende Menüs korrigieren --------------------------- */
  625.  menu=menu->Menu.NextMenu;
  626.  while(menu!=NULL)
  627.   {
  628.    menu->Menu.LeftEdge+=width;
  629.    menu->NextLeftEdge+=width;
  630.    menu=menu->Menu.NextMenu;
  631.   }
  632.  
  633.  if((we->MenuOn)&&(!we->Iconify))
  634.    SetMenuStrip(we->Window,we->FirstMenu);
  635.  return(TRUE);
  636. }
  637.  
  638. /* ---- Barlabel updaten */
  639. void UpdateBarlabel(we,item,width)
  640.  struct WindowEntry *we;
  641.  struct MWMenuItem  *item;
  642.  WORD                width;
  643. {
  644.  struct MultiWindowsUser *mw;
  645.  WORD                     i,l1,add1;
  646.  
  647.  USER;
  648.  
  649.  add1=(width/mw->BarCharSize);
  650.  l1=add1+2;
  651.  if(item->String[0]) FREE2(item->String[0]);
  652.  item->String[0]=ALLOC2(l1);
  653.  if(item->String[0]!=NULL)
  654.   {
  655.    for(i=0;i<add1;i++)
  656.      item->String[0][i]=MultiWindowsBase->MenuBarChar;
  657.    item->String[0][i]=0x00;
  658.    item->ItemText[0].IText=item->String[0];
  659.   }
  660.  else
  661.    NoMemory();
  662. }
  663.  
  664. /* ---- MenuItem initialisieren */
  665. struct MWMenuItem *InitItem(we,leftEdge,boxWidth,commSeqWidth,first,itemID,helpID,textID1,textID2,cmd,flags)
  666.  struct WindowEntry *we;
  667.  WORD                leftEdge;
  668.  WORD               *boxWidth;
  669.  WORD               *commSeqWidth;
  670.  struct MWMenuItem  *first;
  671.  ULONG               itemID;
  672.  ULONG               helpID;
  673.  ULONG               textID1;
  674.  ULONG               textID2;
  675.  UBYTE              *cmd;
  676.  UWORD               flags;
  677. {
  678.  BOOL                     correction;
  679.  UBYTE                   *text1,*text2;
  680.  struct MultiWindowsUser *mw;
  681.  struct MWMenuItem       *item,*sub;
  682.  int                      width,i,s1,s2,l1,l2,add1,add2;
  683.  
  684.  USER;
  685.  item=ALLOC2(sizeof(struct MWMenuItem));
  686.  if(item==NULL) { NoMemory(); return(NULL); }
  687.  
  688.  correction=FALSE;
  689.  if(textID1!=0)
  690.   {
  691.    text1=FindID(mw->Catalog,textID1);
  692.  
  693.    /* ---- Textbreite berechnen, Strings kopieren ------------------ */
  694.    add1=0;
  695.    add2=0;
  696.    width=PixelLength(mw->TextFont,text1);
  697.    if(textID2!=NULL)
  698.     {
  699.      text2=FindID(mw->Catalog,textID2);
  700.  
  701.      /* --- Stringlängen angleichen ---------------- */
  702.      i=PixelLength(mw->TextFont,text2);
  703.      if(width>i) add2=1+((width-i)/mw->SpaceSize);
  704.      if(i>width) add1=1+((i-width)/mw->SpaceSize);
  705.      if(i>width) width=i;
  706.  
  707.      /* --- String 2 kopieren ---------------------- */
  708.      s2=strlen(text2);
  709.      l2=s2+add2+2;
  710.      item->String[1]=ALLOC2(l2);
  711.      if(item->String[1]==NULL)
  712.       { NoMemory(); return(NULL); }
  713.      CopyMem(text2,item->String[1],l2);
  714.      for(i=0;i<add2;i++)
  715.        item->String[1][i+s2]=' ';
  716.      item->String[1][i+s2]=0x00;
  717.     }
  718.  
  719.    /* --- String 1 kopieren ---------------------- */
  720.    s1=strlen(text1);
  721.    l1=s1+add1+2;
  722.    item->String[0]=ALLOC2(l1);
  723.    if(item->String[0]==NULL)
  724.     {
  725.      if(item->String[1]) FREE2(item->String[1]);
  726.      NoMemory(); return(NULL);
  727.     }
  728.    CopyMem(text1,item->String[0],l1);
  729.    for(i=0;i<add1;i++)
  730.      item->String[0][i+s1]=' ';
  731.    item->String[0][i+s1]=0x00;
  732.   }
  733.  else
  734.    width=0;
  735.  
  736.  /* ---- Kommandoauswertung -------------------------------------- */
  737.  if(cmd!=NULL)
  738.   {
  739.    i=strlen(cmd);
  740.    if(i==1)
  741.     {
  742.      item->CommandKey=cmd[0];
  743.      item->CommandFlags=MICF_INTUITION;
  744.      item->MenuItem.Command=cmd[0];
  745.  
  746.      i=COMMWIDTH+PixelLength(mw->TextFont,cmd);
  747.      width+=i;
  748.  
  749.      if(i>*commSeqWidth)
  750.       {
  751.        *commSeqWidth=i;
  752.        correction=TRUE;
  753.       }
  754.     }
  755.    else
  756.     {
  757.      GetCommand(item,cmd);
  758.      i=PixelLength(mw->TextFont,cmd);
  759.      width+=i;
  760.      if(i>*commSeqWidth)
  761.       {
  762.        *commSeqWidth=i;
  763.        correction=TRUE;
  764.       }
  765.     }
  766.   }
  767.  
  768.  width+=MultiWindowsBase->MenuCommSeqSpacing;
  769.  if((flags & CMI_CHECKIT)||(flags & CMI_TOGGLE))  width+=CHECKWIDTH;
  770.  
  771.  if(*boxWidth<width)
  772.   {
  773.    width+=(width % mw->BarCharSize);
  774.    *boxWidth=width;
  775.    correction=TRUE;
  776.   }
  777.  
  778.   /* ---- Barlabel-Auswertung ------------------------------------- */
  779.  if(flags & CMI_BARITEM)
  780.    UpdateBarlabel(we,item,*boxWidth);
  781.  
  782.  /* ---- Korrektur der vorherigen Itemgrößen -------------------- */
  783.  if(flags & CMI_SUBITEM)
  784.    i=*boxWidth-(*boxWidth >> 2);
  785.  else
  786.    i=MultiWindowsBase->MenuItemMove;
  787.  
  788.  l1=leftEdge+i+*boxWidth; /* right edge */
  789.  if(l1>we->Screen->Width-20)
  790.   {
  791.    if((flags & CMI_SUBITEM)&&(l1-(i/2)>we->Screen->Width-20))
  792.      i=-i;
  793.     else
  794.      i-=(l1-(we->Screen->Width-20));
  795.   }
  796.  
  797.  if(correction)
  798.   {
  799.    while(first!=NULL)
  800.     {
  801.      first->MenuItem.Width=*boxWidth;
  802.      first->MenuItem.LeftEdge=i;
  803.  
  804.      if(!(first->Flags & CMI_MASTERITEM))
  805.        first->ItemText[2].LeftEdge=*boxWidth-*commSeqWidth;
  806.      else
  807.        first->ItemText[2].LeftEdge=*boxWidth-mw->SubStringSize;
  808.  
  809.      if(first->Flags & CMI_BARITEM)
  810.        UpdateBarlabel(we,first,*boxWidth);
  811.  
  812.      first=first->MenuItem.NextItem;
  813.     }
  814.   }
  815.  
  816.  /* ---- Initialisieren der Strukturen --------------------------- */
  817.  item->MenuItem.LeftEdge=i;
  818.  item->MenuItem.Width=*boxWidth;
  819.  item->MenuItem.Height=mw->TextFont->tf_YSize+MultiWindowsBase->MenuLineSpacing;
  820.  
  821.  if(flags & CMI_SUBITEM)
  822.   {
  823.    i=mw->TextFont->tf_YSize+MultiWindowsBase->MenuLineSpacing;
  824.    item->MenuItem.TopEdge=i-(i >> 2);
  825.   }
  826.  
  827.  if(flags & CMI_BARITEM)
  828.    item->MenuItem.Flags=ITEMTEXT|HIGHNONE|ITEMENABLED;
  829.  else
  830.   {
  831.    item->MenuItem.Flags=ITEMTEXT|HIGHCOMP|ITEMENABLED;
  832.  
  833.    if(item->CommandFlags==MICF_INTUITION)
  834.      item->MenuItem.Flags |= COMMSEQ;
  835.    if(flags & CMI_DISABLE) item->MenuItem.Flags &= ~ITEMENABLED;
  836.    if(flags & CMI_TOGGLE)
  837.      item->MenuItem.Flags |= MENUTOGGLE|CHECKIT;
  838.    if(flags & CMI_CHECKIT)
  839.      item->MenuItem.Flags |= CHECKIT;
  840.    if(flags & CMI_CHECKED)
  841.      item->MenuItem.Flags |= CHECKED;
  842.   }
  843.  
  844.  for(i=0;i<2;i++)
  845.    CopyMemQuick(GetTextAttr(),&item->TextAttr[i],sizeof(struct TextAttr));
  846.  
  847.  if(flags & CMI_T1BOLD)   item->TextAttr[0].ta_Style |= FSF_BOLD;
  848.  if(flags & CMI_T1ITALIC) item->TextAttr[0].ta_Style |= FSF_ITALIC;
  849.  if(flags & CMI_T2BOLD)   item->TextAttr[1].ta_Style |= FSF_BOLD;
  850.  if(flags & CMI_T2ITALIC) item->TextAttr[1].ta_Style |= FSF_ITALIC;
  851.  
  852.  item->MenuItem.ItemFill=&item->ItemText[0];
  853.  if((flags & CMI_CHECKIT)||(flags & CMI_TOGGLE))
  854.    item->ItemText[0].LeftEdge=CHECKWIDTH;
  855.  item->ItemText[0].TopEdge=1;
  856.  item->ItemText[0].DrawMode=AUTODRAWMODE;
  857.  item->ItemText[0].FrontPen=AUTOFRONTPEN;
  858.  item->ItemText[0].BackPen=AUTOBACKPEN;
  859.  item->ItemText[0].ITextFont=&item->TextAttr[0];
  860.  item->ItemText[0].IText=item->String[0];
  861.  
  862.  if(item->CommandFlags!=MICF_INTUITION)
  863.   {
  864.    item->ItemText[0].NextText=&item->ItemText[2];
  865.    item->ItemText[2].LeftEdge=*boxWidth-*commSeqWidth;
  866.    item->ItemText[2].TopEdge=1;
  867.    item->ItemText[2].DrawMode=AUTODRAWMODE;
  868.    item->ItemText[2].FrontPen=AUTOFRONTPEN;
  869.    item->ItemText[2].BackPen=AUTOBACKPEN;
  870.    item->ItemText[2].ITextFont=mw->BoldTextAttr;
  871.    item->ItemText[2].IText=cmd;
  872.   }
  873.  
  874.  if(item->String[1]!=NULL)
  875.   {
  876.    item->MenuItem.Flags &= ~HIGHCOMP;
  877.    item->MenuItem.Flags |= HIGHIMAGE;
  878.    item->MenuItem.SelectFill=&item->ItemText[1];
  879.    if((flags & CMI_CHECKIT)||(flags & CMI_TOGGLE))
  880.      item->ItemText[1].LeftEdge=CHECKWIDTH;
  881.    item->ItemText[1].TopEdge=1;
  882.    item->ItemText[1].DrawMode=AUTODRAWMODE;
  883.    item->ItemText[1].FrontPen=AUTOFRONTPEN;
  884.    item->ItemText[1].BackPen=AUTOBACKPEN;
  885.    item->ItemText[1].ITextFont=&item->TextAttr[1];
  886.    item->ItemText[1].IText=item->String[1];
  887.   }
  888.  
  889.  item->ItemID=itemID;
  890.  item->HelpID=helpID;
  891.  item->Flags=flags;
  892.  
  893.  return(item);
  894. }
  895.  
  896. /* ---- MenuItem hinzufügen */
  897. BOOL AddItem(itemID,helpID,textID1,textID2,cmd,flags)
  898.  ULONG  itemID;
  899.  ULONG  helpID;
  900.  ULONG  textID1;
  901.  ULONG  textID2;
  902.  UBYTE *cmd;
  903.  UWORD  flags;
  904. {
  905.  struct MultiWindowsUser *mw;
  906.  struct WindowEntry      *we;
  907.  struct MWMenu           *menu;
  908.  struct MWMenuItem       *item,*prev;
  909.  
  910.  USER;
  911.  WE;
  912.  if(we==NULL) return(FALSE);
  913.  
  914.  menu=we->LastMenu;
  915.  if(menu==NULL) return(FALSE);
  916.  
  917.  item=InitItem(we,menu->Menu.LeftEdge,&menu->BoxWidth,&menu->KeyLeft,menu->Menu.FirstItem,itemID,helpID,textID1,textID2,cmd,flags);
  918.  if(item==NULL) return(FALSE);
  919.  
  920.  if((we->MenuOn)&&(!we->Iconify))
  921.    ClearMenuStrip(we->Window);
  922.  
  923.  /* ---- Menüstruktur einrichten ------------- */
  924.  prev=we->LastMenuItem;
  925.  if(prev!=NULL)
  926.    item->MenuItem.TopEdge=prev->NextTopEdge;
  927.  item->NextTopEdge=item->MenuItem.TopEdge+item->MenuItem.Height;
  928.  
  929.  /* ---- Menü an Liste anfügen --------------- */
  930.  if(prev!=NULL)
  931.    prev->MenuItem.NextItem=item;
  932.  else
  933.    menu->Menu.FirstItem=item;
  934.  
  935.  we->LastSubItem=NULL;
  936.  we->LastMenuItem=item;
  937.  
  938.  if((we->MenuOn)&&(!we->Iconify))
  939.    SetMenuStrip(we->Window,we->FirstMenu);
  940.  
  941.  return(TRUE);
  942. }
  943.  
  944. /* ---- Sub-Item hinzufügen */
  945. BOOL AddSubItem(subID,helpID,textID1,textID2,cmd,flags)
  946.  ULONG  subID;
  947.  ULONG  helpID;
  948.  ULONG  textID1;
  949.  ULONG  textID2;
  950.  UBYTE *cmd;
  951.  UWORD  flags;
  952. {
  953.  struct MultiWindowsUser *mw;
  954.  struct WindowEntry      *we;
  955.  struct MWMenu           *menu;
  956.  struct MWMenuItem       *sub,*item,*prev;
  957.  int                      i;
  958.  
  959.  USER;
  960.  WE;
  961.  if(we==NULL) return(FALSE);
  962.  
  963.  item=we->LastMenuItem;
  964.  if(item==NULL) return(FALSE);
  965.  
  966.  i=we->LastMenu->Menu.LeftEdge+item->MenuItem.LeftEdge;
  967.  sub=InitItem(we,i,&item->SubBoxWidth,&item->SubKeyLeft,item->MenuItem.SubItem,subID,helpID,textID1,textID2,cmd,flags | CMI_SUBITEM);
  968.  if(sub==NULL) return(FALSE);
  969.  MasterItem(we->LastMenu,item);
  970.  
  971.  if((we->MenuOn)&&(!we->Iconify))
  972.    ClearMenuStrip(we->Window);
  973.  
  974.  /* ---- Menüstruktur einrichten ------------- */
  975.  prev=we->LastSubItem;
  976.  
  977.  if(prev!=NULL)
  978.    sub->MenuItem.TopEdge=prev->NextTopEdge;
  979.  sub->NextTopEdge=sub->MenuItem.TopEdge+sub->MenuItem.Height;
  980.  
  981.  /* ---- Menü an Liste anfügen --------------- */
  982.  if(prev!=NULL)
  983.    prev->MenuItem.NextItem=sub;
  984.  else
  985.    item->MenuItem.SubItem=sub;
  986.  we->LastSubItem=sub;
  987.  
  988.  if((we->MenuOn)&&(!we->Iconify))
  989.    SetMenuStrip(we->Window,we->FirstMenu);
  990.  
  991.  return(TRUE);
  992. }
  993.  
  994. /* ---- ToggleSelect-Item hinzufügen */
  995. BOOL AddToggleItem(itemID,helpID,textID1,textID2,cmd,flags,checkIt)
  996.  ULONG  itemID;
  997.  ULONG  helpID;
  998.  ULONG  textID1;
  999.  ULONG  textID2;
  1000.  UBYTE *cmd;
  1001.  UWORD  flags;
  1002.  BOOL   checkIt;
  1003. {
  1004.  if(checkIt) flags |= CMI_CHECKED;
  1005.  return(AddItem(itemID,helpID,textID1,textID2,cmd,flags | CMI_TOGGLE));
  1006. }
  1007.  
  1008. /* ---- ToggleSelect-Sub-Item hinzufügen */
  1009. BOOL AddSubToggleItem(subID,helpID,textID1,textID2,cmd,flags,checkIt)
  1010.  ULONG  subID;
  1011.  ULONG  helpID;
  1012.  ULONG  textID1;
  1013.  ULONG  textID2;
  1014.  UBYTE *cmd;
  1015.  UWORD  flags;
  1016.  BOOL   checkIt;
  1017. {
  1018.  if(checkIt) flags |= CMI_CHECKED;
  1019.  return(AddSubItem(subID,helpID,textID1,textID2,cmd,flags | CMI_TOGGLE));
  1020. }
  1021.  
  1022. /* ----Check-Item hinzufügen */
  1023. BOOL AddCheckItem(itemID,helpID,textID1,textID2,cmd,flags,checkIt)
  1024.  ULONG  itemID;
  1025.  ULONG  helpID;
  1026.  ULONG  textID1;
  1027.  ULONG  textID2;
  1028.  UBYTE *cmd;
  1029.  UWORD  flags;
  1030.  BOOL   checkIt;
  1031. {
  1032.  if(checkIt) flags |= CMI_CHECKED;
  1033.  return(AddItem(itemID,helpID,textID1,textID2,cmd,flags | CMI_CHECKIT));
  1034. }
  1035.  
  1036. /* ---- Check-Sub-Item hinzufügen */
  1037. BOOL AddSubCheckItem(subID,helpID,textID1,textID2,cmd,flags,checkIt)
  1038.  ULONG  subID;
  1039.  ULONG  helpID;
  1040.  ULONG  textID1;
  1041.  ULONG  textID2;
  1042.  UBYTE *cmd;
  1043.  UWORD  flags;
  1044.  BOOL   checkIt;
  1045. {
  1046.  if(checkIt) flags |= CMI_CHECKED;
  1047.  return(AddSubItem(subID,helpID,textID1,textID2,cmd,flags | CMI_CHECKIT));
  1048. }
  1049.  
  1050. /* ---- Item verändern und abfragen */
  1051. BOOL ModifyItem(itemID,modifyFlags,flag)
  1052.  ULONG itemID;
  1053.  UBYTE modifyFlags;
  1054.  UWORD flag;
  1055. {
  1056.  BOOL                res;
  1057.  struct WindowEntry *we;
  1058.  struct MWMenuItem  *item;
  1059.  
  1060.  WE;
  1061.  if(we==NULL) return(FALSE);
  1062.  
  1063.  if(modifyFlags & MIF_SUBITEM)
  1064.    item=FindSubItem(itemID);
  1065.  else
  1066.    item=FindItem(itemID);
  1067.  if(item==NULL) return(FALSE);
  1068.  
  1069.  if(modifyFlags & MIF_CHECKIT)
  1070.    if(!(item->MenuItem.Flags & CHECKIT)) return(FALSE);
  1071.  
  1072.  res=FALSE;
  1073.  if((we->MenuOn)&&(!we->Iconify)&&(!(modifyFlags & MIF_ASK)))
  1074.    ClearMenuStrip(we->Window);
  1075.  
  1076.    if(modifyFlags & MIF_UNSET)
  1077.      item->MenuItem.Flags &= ~flag;
  1078.    else if(modifyFlags & MIF_SET)
  1079.      item->MenuItem.Flags |= flag;
  1080.    else
  1081.      if(item->MenuItem.Flags & flag) res=TRUE;
  1082.  
  1083.  if((we->MenuOn)&&(!we->Iconify)&&(!(modifyFlags & MIF_ASK)))
  1084.    SetMenuStrip(we->Window,we->FirstMenu);
  1085.  
  1086.  return(res);
  1087. }
  1088.  
  1089. /* ---- Item disablen */
  1090. void DisableItem(itemID)
  1091.  ULONG itemID;
  1092. {
  1093.  ModifyItem(itemID,MIF_UNSET,ITEMENABLED);
  1094. }
  1095.  
  1096. /* ---- Item enablen */
  1097. void EnableItem(itemID)
  1098.  ULONG itemID;
  1099. {
  1100.  ModifyItem(itemID,MIF_SET,ITEMENABLED);
  1101. }
  1102.  
  1103. /* ---- Item checken */
  1104. void CheckItem(itemID)
  1105.  ULONG itemID;
  1106. {
  1107.  ModifyItem(itemID,MIF_SET|MIF_CHECKIT,CHECKED);
  1108. }
  1109.  
  1110. /* ---- Item unchecken */
  1111. void UnCheckItem(itemID)
  1112.  ULONG itemID;
  1113. {
  1114.  ModifyItem(itemID,MIF_UNSET|MIF_CHECKIT,CHECKED);
  1115. }
  1116.  
  1117. /* ---- SubItem disablen */
  1118. void DisableSubItem(subID)
  1119.  ULONG subID;
  1120. {
  1121.  ModifyItem(subID,MIF_SUBITEM|MIF_UNSET,ITEMENABLED);
  1122. }
  1123.  
  1124. /* ---- SubItem enablen */
  1125. void EnableSubItem(subID)
  1126.  ULONG subID;
  1127. {
  1128.  ModifyItem(subID,MIF_SUBITEM|MIF_SET,ITEMENABLED);
  1129. }
  1130.  
  1131. /* ---- SubItem checken */
  1132. void CheckSubItem(subID)
  1133.  ULONG subID;
  1134. {
  1135.  ModifyItem(subID,MIF_SUBITEM|MIF_SET|MIF_CHECKIT,CHECKED);
  1136. }
  1137.  
  1138. /* ---- SubItem unchecken */
  1139. void UnCheckSubItem(subID)
  1140.  ULONG subID;
  1141. {
  1142.  ModifyItem(subID,MIF_SUBITEM|MIF_UNSET|MIF_CHECKIT,CHECKED);
  1143. }
  1144.  
  1145. /* ---- Item abfragen */
  1146. BOOL AskItem(itemID)
  1147.  ULONG itemID;
  1148. {
  1149.  return(ModifyItem(itemID,MIF_ASK|MIF_CHECKIT,CHECKED));
  1150. }
  1151.  
  1152. /* ---- SubItem abfragen */
  1153. BOOL AskSubItem(subID)
  1154.  ULONG subID;
  1155. {
  1156.  return(ModifyItem(subID,MIF_SUBITEM|MIF_ASK|MIF_CHECKIT,CHECKED));
  1157. }
  1158.  
  1159. /* ---- Item entfernen */
  1160. void RemItem(itemID)
  1161.  ULONG itemID;
  1162. {
  1163.  struct WindowEntry *we;
  1164.  struct MWMenuItem  *item,*next;
  1165.  WORD                height;
  1166.  
  1167.  WE;
  1168.  if(we==NULL) return;
  1169.  
  1170.  item=FindItem(itemID);
  1171.  if(item==NULL) return;
  1172.  
  1173.  if((we->MenuOn)&&(!we->Iconify))
  1174.    ClearMenuStrip(we->Window);
  1175.  
  1176.  /* ---- Item aus Liste entfernen ----------------------------- */
  1177.  
  1178.  if(item->FindPrevItem)
  1179.    item->FindPrevItem->MenuItem.NextItem=item->MenuItem.NextItem;
  1180.  else
  1181.    item->FindMenu->Menu.FirstItem=item->MenuItem.NextItem;
  1182.  
  1183.  next=item->MenuItem.NextItem;
  1184.  height=item->MenuItem.Height;
  1185.  if(item->String[0]) FREE2(item->String[0]);
  1186.  if(item->String[1]) FREE2(item->String[1]);
  1187.  FreeMemory(&item->Remember);
  1188.  FREE2(item);
  1189.  
  1190.  /* ---- Folgende Items korrigieren --------------------------- */
  1191.  while(next!=NULL)
  1192.   {
  1193.    next->MenuItem.TopEdge-=height;
  1194.    next->NextTopEdge-=height;
  1195.    next=next->MenuItem.NextItem;
  1196.   }
  1197.  
  1198.  UpdateLast(we);
  1199.  
  1200.  if((we->MenuOn)&&(!we->Iconify))
  1201.    SetMenuStrip(we->Window,we->FirstMenu);
  1202. }
  1203.  
  1204. /* ---- SubItem entfernen */
  1205. void RemSubItem(subID)
  1206.  ULONG subID;
  1207. {
  1208.  struct WindowEntry *we;
  1209.  struct MWMenuItem  *sub,*next;
  1210.  WORD                height;
  1211.  
  1212.  WE;
  1213.  if(we==NULL) return;
  1214.  
  1215.  sub=FindSubItem(subID);
  1216.  if(sub==NULL) return;
  1217.  
  1218.  if((we->MenuOn)&&(!we->Iconify))
  1219.    ClearMenuStrip(we->Window);
  1220.  
  1221.  /* ---- Item aus Liste entfernen ----------------------------- */
  1222.  
  1223.  we->LastMenu=NULL;
  1224.  we->LastMenuItem=NULL;
  1225.  we->LastSubItem=NULL;
  1226.  
  1227.  if(sub->FindPrevItem)
  1228.    sub->FindPrevItem->MenuItem.NextItem=sub->MenuItem.NextItem;
  1229.  else
  1230.    sub->FindMasterItem->MenuItem.SubItem=sub->MenuItem.NextItem;
  1231.  
  1232.  next=sub->MenuItem.NextItem;
  1233.  height=sub->MenuItem.Height;
  1234.  if(sub->String[0]) FREE2(sub->String[0]);
  1235.  if(sub->String[1]) FREE2(sub->String[1]);
  1236.  FreeMemory(&sub->Remember);
  1237.  FREE2(sub);
  1238.  
  1239.  /* ---- Folgende Items korrigieren --------------------------- */
  1240.  while(next!=NULL)
  1241.   {
  1242.    next->MenuItem.TopEdge-=height;
  1243.    next->NextTopEdge-=height;
  1244.    next=next->MenuItem.NextItem;
  1245.   }
  1246.  
  1247.  UpdateLast(we);
  1248.  
  1249.  if((we->MenuOn)&&(!we->Iconify))
  1250.    SetMenuStrip(we->Window,we->FirstMenu);
  1251. }
  1252.  
  1253. /* ---- Bar-Item hinzufügen */
  1254. BOOL AddBarItem(itemID)
  1255.  ULONG  itemID;
  1256. {
  1257.  return(AddItem(itemID,0,0,0,0,CMI_BARITEM));
  1258. }
  1259.  
  1260. /* ---- Bar-Sub-Item hinzufügen */
  1261. BOOL AddSubBarItem(subID)
  1262.  ULONG  subID;
  1263. {
  1264.  return(AddSubItem(subID,0,0,0,0,CMI_BARITEM));
  1265. }
  1266.  
  1267. /* ---- Menü-Item einfügen */
  1268. BOOL InsertItem(prevID,itemID,helpID,textID1,textID2,cmd,flags)
  1269.  ULONG  prevID;
  1270.  ULONG  itemID;
  1271.  ULONG  helpID;
  1272.  ULONG  textID1;
  1273.  ULONG  textID2;
  1274.  UBYTE *cmd;
  1275.  UWORD  flags;
  1276. {
  1277.  UBYTE                    type;
  1278.  struct MultiWindowsUser *mw;
  1279.  struct WindowEntry      *we;
  1280.  struct MWMenu           *menu;
  1281.  struct MWMenuItem       *item,*prev;
  1282.  int                      height;
  1283.  
  1284.  USER;
  1285.  WE;
  1286.  if(we==NULL) return(FALSE);
  1287.  
  1288.  prev=FindMenuOrItem(prevID,&type);
  1289.  if(prev==NULL) return(FALSE);
  1290.  
  1291.  if(type==FINDTYPE_ITEM)
  1292.   { menu=prev->FindMenu; }
  1293.  else
  1294.   {
  1295.    menu=prev;    /* prevID ist ein Menü, kein Item */
  1296.    prev=NULL;
  1297.   }
  1298.  
  1299.  item=InitItem(we,menu->Menu.LeftEdge,&menu->BoxWidth,&menu->KeyLeft,menu->Menu.FirstItem,itemID,helpID,textID1,textID2,cmd,flags);
  1300.  if(item==NULL) return(FALSE);
  1301.  
  1302.  if((we->MenuOn)&&(!we->Iconify))
  1303.    ClearMenuStrip(we->Window);
  1304.  
  1305.  /* ---- Menüstruktur einrichten ------------- */
  1306.  if(prev!=NULL)
  1307.    item->MenuItem.TopEdge=prev->NextTopEdge;
  1308.  
  1309.  item->NextTopEdge=item->MenuItem.TopEdge+item->MenuItem.Height;
  1310.  height=item->MenuItem.Height;
  1311.  
  1312.  /* ---- Menü an Liste anfügen --------------- */
  1313.  if(prev!=NULL)
  1314.   {
  1315.    item->MenuItem.NextItem=prev->MenuItem.NextItem;
  1316.    prev->MenuItem.NextItem=item;
  1317.   }
  1318.  else
  1319.   {
  1320.    item->MenuItem.NextItem=menu->Menu.FirstItem;
  1321.    menu->Menu.FirstItem=item;
  1322.   }
  1323.  
  1324.  /* ---- folgende Items korrigieren ---------- */
  1325.  item=item->MenuItem.NextItem;
  1326.  while(item!=NULL)
  1327.   {
  1328.    item->MenuItem.TopEdge+=height;
  1329.    item->MenuItem.NextTopEdge+=height;
  1330.    item=item->MenuItem.NextItem;
  1331.   }
  1332.  UpdateLast(we);
  1333.  
  1334.  if((we->MenuOn)&&(!we->Iconify))
  1335.    SetMenuStrip(we->Window,we->FirstMenu);
  1336.  
  1337.  return(TRUE);
  1338. }
  1339.  
  1340. /* ---- Sub-Item einfügen */
  1341. BOOL InsertSubItem(prevID,subID,helpID,textID1,textID2,cmd,flags)
  1342.  ULONG  prevID;
  1343.  ULONG  subID;
  1344.  ULONG  helpID;
  1345.  ULONG  textID1;
  1346.  ULONG  textID2;
  1347.  UBYTE *cmd;
  1348.  UWORD  flags;
  1349. {
  1350.  struct MultiWindowsUser *mw;
  1351.  struct WindowEntry      *we;
  1352.  struct MWMenu           *menu;
  1353.  struct MWMenuItem       *sub,*prev,*item;
  1354.  int                      i,height;
  1355.  
  1356.  USER;
  1357.  WE;
  1358.  if(we==NULL) return(FALSE);
  1359.  
  1360.  prev=FindItemOrSubItem(prevID);
  1361.  if(prev==NULL) return(FALSE);
  1362.  item=prev->FindMasterItem;
  1363.  menu=prev->FindMenu;
  1364.  
  1365.  if(item==NULL)
  1366.   {
  1367.    item=prev; prev=NULL;   /* prevID ist ein Item, kein Sub-Item */
  1368.   }
  1369.  
  1370.  i=menu->Menu.LeftEdge+item->MenuItem.LeftEdge;
  1371.  sub=InitItem(we,i,&item->SubBoxWidth,&item->SubKeyLeft,item->MenuItem.SubItem,subID,helpID,textID1,textID2,cmd,flags | CMI_SUBITEM);
  1372.  if(sub==NULL) return(FALSE);
  1373.  MasterItem(menu,item);
  1374.  
  1375.  if((we->MenuOn)&&(!we->Iconify))
  1376.    ClearMenuStrip(we->Window);
  1377.  
  1378.  /* ---- Menüstruktur einrichten ------------- */
  1379.  if(prev!=NULL)
  1380.    sub->MenuItem.TopEdge=prev->NextTopEdge;
  1381.  
  1382.  sub->NextTopEdge=sub->MenuItem.TopEdge+sub->MenuItem.Height;
  1383.  height=sub->MenuItem.Height;
  1384.  
  1385.  /* ---- Menü an Liste anfügen --------------- */
  1386.  if(prev!=NULL)
  1387.   {
  1388.    sub->MenuItem.NextItem=prev->MenuItem.NextItem;
  1389.    prev->MenuItem.NextItem=sub;
  1390.   }
  1391.  else
  1392.   {
  1393.    sub->MenuItem.NextItem=item->MenuItem.SubItem;
  1394.    item->MenuItem.SubItem=sub;
  1395.   }
  1396.  
  1397.  /* ---- folgende Items korrigieren ---------- */
  1398.  sub=sub->MenuItem.NextItem;
  1399.  while(sub!=NULL)
  1400.   {
  1401.    sub->MenuItem.TopEdge+=height;
  1402.    sub->MenuItem.NextTopEdge+=height;
  1403.    sub=sub->MenuItem.NextItem;
  1404.   }
  1405.  UpdateLast(we);
  1406.  
  1407.  if((we->MenuOn)&&(!we->Iconify))
  1408.    SetMenuStrip(we->Window,we->FirstMenu);
  1409.  
  1410.  return(TRUE);
  1411. }
  1412.  
  1413. /* ---- Bar-Item einfügen */
  1414. BOOL InsertBarItem(prevID,itemID)
  1415.  ULONG prevID,itemID;
  1416. {
  1417.  return(InsertItem(prevID,itemID,0,0,0,0,CMI_BARITEM));
  1418. }
  1419.  
  1420. /* ---- Bar-Sub-Item einfügen */
  1421. BOOL InsertSubBarItem(prevID,subID)
  1422.  ULONG prevID,subID;
  1423. {
  1424.  return(InsertSubItem(prevID,subID,0,0,0,0,CMI_BARITEM));
  1425. }
  1426.  
  1427. /* ---- ToggleSelect-Item einfügen */
  1428. BOOL InsertToggleItem(prevID,itemID,helpID,textID1,textID2,cmd,flags,checkIt)
  1429.  ULONG  prevID;
  1430.  ULONG  itemID;
  1431.  ULONG  helpID;
  1432.  ULONG  textID1;
  1433.  ULONG  textID2;
  1434.  UBYTE *cmd;
  1435.  UWORD  flags;
  1436.  BOOL   checkIt;
  1437. {
  1438.  if(checkIt) flags |= CMI_CHECKED;
  1439.  return(InsertItem(prevID,itemID,helpID,textID1,textID2,cmd,flags | CMI_TOGGLE));
  1440. }
  1441.  
  1442. /* ---- ToggleSelect-Sub-Item einfügen */
  1443. BOOL InsertSubToggleItem(prevID,subID,helpID,textID1,textID2,cmd,flags,checkIt)
  1444.  ULONG  prevID;
  1445.  ULONG  subID;
  1446.  ULONG  helpID;
  1447.  ULONG  textID1;
  1448.  ULONG  textID2;
  1449.  UBYTE *cmd;
  1450.  UWORD  flags;
  1451.  BOOL   checkIt;
  1452. {
  1453.  if(checkIt) flags |= CMI_CHECKED;
  1454.  return(InsertSubItem(prevID,subID,helpID,textID1,textID2,cmd,flags | CMI_TOGGLE));
  1455. }
  1456.  
  1457. /* ----Check-Item einfügen */
  1458. BOOL InsertCheckItem(prevID,itemID,helpID,textID1,textID2,cmd,flags,checkIt)
  1459.  ULONG  prevID;
  1460.  ULONG  itemID;
  1461.  ULONG  helpID;
  1462.  ULONG  textID1;
  1463.  ULONG  textID2;
  1464.  UBYTE *cmd;
  1465.  UWORD  flags;
  1466.  BOOL   checkIt;
  1467. {
  1468.  if(checkIt) flags |= CMI_CHECKED;
  1469.  return(InsertItem(prevID,itemID,helpID,textID1,textID2,cmd,flags | CMI_CHECKIT));
  1470. }
  1471.  
  1472. /* ---- Check-Sub-Item einfügen */
  1473. BOOL InsertSubCheckItem(prevID,subID,helpID,textID1,textID2,cmd,flags,checkIt)
  1474.  ULONG  prevID;
  1475.  ULONG  subID;
  1476.  ULONG  helpID;
  1477.  ULONG  textID1;
  1478.  ULONG  textID2;
  1479.  UBYTE *cmd;
  1480.  UWORD  flags;
  1481.  BOOL   checkIt;
  1482. {
  1483.  if(checkIt) flags |= CMI_CHECKED;
  1484.  return(InsertSubItem(prevID,subID,helpID,textID1,textID2,cmd,flags | CMI_CHECKIT));
  1485. }
  1486.  
  1487. /* ---- Command-String auswerten */
  1488. void GetCommand(item,cmd)
  1489.  struct MWMenuItem *item;
  1490.  UBYTE             *cmd;
  1491. {
  1492.  UBYTE  str[200];
  1493.  UBYTE *s;
  1494.  int    i,j,l;
  1495.  
  1496.  strcpy(&str,cmd);
  1497.  l=strlen(&str);
  1498.  
  1499.  s=&str;
  1500.  for(i=0;i<=l;i++)
  1501.   {
  1502.    if((str[i]=='-')||(str[i]=='+')||(str[i]==0x00))
  1503.     {
  1504.      str[i]=0x00;
  1505.      /* ---------------------------------- */
  1506.      j=strlen(s);
  1507.      if(j==1)
  1508.       {
  1509.        item->CommandKey=toupper(s[0]);
  1510.       }
  1511.      else
  1512.       {
  1513.        if(s[0]=='F')
  1514.         {
  1515.          if((j==2)&&(s[1]>='1')&&(s[1]<='9'))
  1516.           {
  1517.            item->CommandKey=s[1]-49;
  1518.            item->CommandFlags |= MICF_FKEY;
  1519.           }
  1520.          else if(!(strncmp(s,"F10")))
  1521.           {
  1522.            item->CommandKey=9;
  1523.            item->CommandFlags |= MICF_FKEY;
  1524.           }
  1525.         }
  1526.        else
  1527.         {
  1528.          if(!(strcmp(s,"ALT"))) item->CommandFlags |= MICF_ALT;
  1529.          else if(!(strcmp(s,"SHIFT"))) item->CommandFlags |= MICF_SHIFT;
  1530.          else if(!(strcmp(s,"CTRL"))) item->CommandFlags |= MICF_CTRL;
  1531.          else if(!(strcmp(s,"AMIGA"))) item->CommandFlags |= MICF_AMIGAR;
  1532.          else if(!(strcmp(s,"RAMIGA"))) item->CommandFlags |= MICF_AMIGAR;
  1533.          else if(!(strcmp(s,"LAMIGA"))) item->CommandFlags |= MICF_AMIGAL;
  1534.          else if(!(strcmp(s,"HELP")))
  1535.           {
  1536.            item->CommandFlags |= MICF_HELP;
  1537.            item->CommandKey=0x5f;
  1538.           }
  1539.          else
  1540.           {
  1541.            j=0;
  1542.            while(MultiWindowsBase->CommandTable[j]->CommandString!=NULL)
  1543.             {
  1544.              if(!(strcmp(s,MultiWindowsBase->CommandTable[j]->CommandString)))
  1545.               {
  1546.                item->CommandKey=MultiWindowsBase->CommandTable[j]->CommandKey;
  1547.                break;
  1548.               }
  1549.              j++;
  1550.             }
  1551.           }
  1552.         }
  1553.       }
  1554.  
  1555.      /* ---------------------------------- */
  1556.      i++; s=&str[i];
  1557.     }
  1558.    else
  1559.      str[i]=toupper(str[i]);
  1560.   }
  1561. }
  1562.  
  1563. /* ---- Standard-Menü-Texte */
  1564. UBYTE *HelpText[]=
  1565. {
  1566.  "500§Help",
  1567.  "501§~C~U~BThe 'Help' menu\nHere you can switch on/off the online help, load the guide file,\n"
  1568.     "see informations about the online help and switch on/off the developer's mode.",
  1569.  "502§Online Help",
  1570.  "503§~C~U~BThe 'Online Help' item\nHere you can switch the Online Help on or off.",
  1571.  "504§Load guide...",
  1572.  "505§~C~U~BThe 'Load guide' item\nThis item will load the guide file of the application.",
  1573.  "506§About Online Help...",
  1574.  "507§~C~U~BThe 'About Online Help' item\nHere you can see informations about the Online Help",
  1575.  "508§Developer's mode",
  1576.  "509§~C~U~BThe 'Developer's mode' item\nHere you can switch the developer's mode on or off.\n"
  1577.     "This will show informations about IDs instead of help texts.",
  1578. };
  1579.  
  1580. /* ---- Standard-Menüs erzeugen */
  1581. void AddStdMenus()
  1582. {
  1583.  BOOL                     bool,off;
  1584.  UWORD                    flags;
  1585.  struct MultiWindowsUser *mw;
  1586.  struct WindowEntry      *we;
  1587.  struct MWMenu           *menu;
  1588.  
  1589.  USER;
  1590.  WE;
  1591.  if(we==NULL) return;
  1592.  
  1593.  /* --- Vorbereitungen ----------------------------------------------- */
  1594.  if(we->MenuOn)
  1595.   {
  1596.    HideMenu();
  1597.    off=TRUE;
  1598.   }
  1599.  else
  1600.   off=FALSE;
  1601.  
  1602.  /* --- Hilfe-Menü --------------------------------------------------- */
  1603.  bool=AddMenu(-1L,HelpText[1],HelpText[0],CME_SYSMENU);
  1604.  if(bool)
  1605.   {
  1606.    menu=we->LastMenu;
  1607.    menu->Menu.LeftEdge=(we->Screen->Width-20)-menu->Menu.Width;
  1608.   }
  1609.  else
  1610.    return;
  1611.  
  1612.  /* --- Hilfe aktivieren --------------------------------------------- */
  1613.  bool=AddToggleItem(STDITEM_ONLINEHELP,HelpText[3],HelpText[2],0,"Shift-Help",CMI_SYSITEM,mw->HelpOn);
  1614.  if(bool) we->HelpOnItem=we->LastMenuItem;
  1615.  
  1616.  /* --- Guide laden -------------------------------------------------- */
  1617.  flags=CMI_SYSITEM;
  1618.  if(mw->GuideName==NULL) flags |= CMI_DISABLE;
  1619.  AddItem(STDITEM_LOADGUIDE,HelpText[5],HelpText[4],0,"Alt-Help",flags);
  1620.  
  1621.  /* --- About -------------------------------------------------------- */
  1622.  AddItem(-1L,0,0,0,0L,CMI_BARITEM|CMI_SYSITEM);
  1623.  AddItem(STDITEM_ABOUTHELP,HelpText[7],HelpText[6],0,"Alt-Shift-Help",CMI_SYSITEM);
  1624.  AddItem(-1L,0,0,0,0L,CMI_BARITEM|CMI_SYSITEM);
  1625.  
  1626.  /* --- Developer's mode --------------------------------------------- */
  1627.  bool=AddToggleItem(STDITEM_DEVELOPER,HelpText[9],HelpText[8],0,"Ctrl-Help",CMI_SYSITEM,mw->DeveloperOn);
  1628.  if(bool) we->DeveloperOnItem=we->LastMenuItem;
  1629.  
  1630.  if(off) ShowMenu();
  1631. }
  1632.  
  1633. /* ---- Ausgewähltes Item suchen */
  1634. void FindActiveItem(we)
  1635.  struct WindowEntry *we;
  1636. {
  1637.  struct MWMenu      *menu;
  1638.  struct MWMenuItem  *item;
  1639.  struct MWMenuItem  *sub;
  1640.  
  1641.  WE;
  1642.  if(we==NULL) return;
  1643.  
  1644.  we->MHMenu=NULL;
  1645.  we->MHMenuItem=NULL;
  1646.  we->MHSubItem=NULL;
  1647.  
  1648.  menu=we->FirstMenu;
  1649.  while(menu!=NULL)
  1650.   {
  1651.    if(menu->Menu.Flags & MIDRAWN)
  1652.     {
  1653.      we->MHMenu=menu;
  1654.  
  1655.      /* --- Menü ist gezeichnet ------------------------ */
  1656.      item=menu->Menu.FirstItem;
  1657.      while(item!=NULL)
  1658.       {
  1659.  
  1660.  
  1661.        if(item->MenuItem.Flags & ISDRAWN)
  1662.         {
  1663.          we->MHMenuItem=item;
  1664.          /* --- Sub-Menüs sind gezeichnet -------------- */
  1665.          sub=item->MenuItem.SubItem;
  1666.          while(sub!=NULL)
  1667.           {
  1668.            if(sub->MenuItem.Flags & HIGHITEM)
  1669.             {
  1670.              if(!(sub->Flags & CMI_BARITEM))
  1671.                we->MHSubItem=sub;
  1672.              return;
  1673.             }
  1674.            sub=sub->MenuItem.NextItem;
  1675.           }
  1676.          /* -------------------------------------------- */
  1677.          return;
  1678.         }
  1679.        else if(item->MenuItem.Flags & HIGHITEM)
  1680.         {
  1681.          /* --- Item ist selektiert -------------------- */
  1682.          if(!(item->Flags & CMI_BARITEM))
  1683.            we->MHMenuItem=item;
  1684.          /* -------------------------------------------- */
  1685.          return;
  1686.         }
  1687.  
  1688.  
  1689.        /* ---------------------------------------------- */
  1690.        item=item->MenuItem.NextItem;
  1691.       }
  1692.      /* ------------------------------------------------ */
  1693.      return;
  1694.     }
  1695.    menu=menu->Menu.NextMenu;
  1696.   }
  1697.  return;
  1698. }
  1699.  
  1700. /* ---- Master-Item initialisieren */
  1701. void MasterItem(menu,item)
  1702.  struct MWMenu     *menu;
  1703.  struct MWMenuItem *item;
  1704. {
  1705.  struct MultiWindowsUser *mw;
  1706.  
  1707.  USER;
  1708.  item->Flags |= CMI_MASTERITEM;
  1709.  item->MenuItem.Flags &= ~COMMSEQ;
  1710.  item->CommandFlags=MICF_NONE;
  1711.  item->CommandKey=0;
  1712.  
  1713.  item->ItemText[0].NextText=&item->ItemText[2];
  1714.  item->ItemText[2].LeftEdge=menu->BoxWidth-mw->SubStringSize;
  1715.  item->ItemText[2].TopEdge=1;
  1716.  item->ItemText[2].DrawMode=AUTODRAWMODE;
  1717.  item->ItemText[2].FrontPen=AUTOFRONTPEN;
  1718.  item->ItemText[2].BackPen=AUTOBACKPEN;
  1719.  item->ItemText[2].ITextFont=mw->BoldTextAttr;
  1720.  item->ItemText[2].IText=MultiWindowsBase->MenuSubString;
  1721. }
  1722.  
  1723. /* ---- RawKey nach VanillaKey konviertieren */
  1724. UBYTE ConvertToVanillaKey(code,qualifier)
  1725.  UBYTE code,qualifier;
  1726. {
  1727.  struct InputEvent ie;
  1728.  UBYTE             buffer[2];
  1729.  LONG              i;
  1730.  
  1731.  ie.ie_NextEvent=NULL;
  1732.  ie.ie_Class=IECLASS_RAWKEY;
  1733.  ie.ie_SubClass=0;
  1734.  ie.ie_Code=code;
  1735.  ie.ie_Qualifier=qualifier;
  1736.  ie.ie_EventAddress=NULL;
  1737.  i=MapRawKey(&ie,&buffer,1L,NULL);
  1738.  if(i==-1) return(0x00);
  1739.  return(buffer[0]);
  1740. }
  1741.  
  1742. /* ---- VanillaKey nach RawKey konvertieren */
  1743. void ConvertToRawKey(code,buffer)
  1744.  UBYTE  code;
  1745.  UBYTE *buffer;
  1746. {
  1747.  UBYTE str[2];
  1748.  
  1749.  str[0]=code;
  1750.  str[1]=0x00;
  1751.  MapANSI(&str,1,buffer,6,NULL);
  1752. }
  1753.  
  1754. /* ---- Menu-Item zu Tastenkombination suchen */
  1755. struct MWMenuItem *FindKeyItem(we,code,qualifier,raw)
  1756.  struct WindowEntry *we;
  1757.  UBYTE               code;
  1758.  ULONG               qualifier;
  1759.  BOOL                raw;
  1760. {
  1761.  UWORD              flags;
  1762.  struct MWMenuItem *menu;
  1763.  struct MWMenuItem *item,*sub;
  1764.  UBYTE              buffer[12];
  1765.  
  1766.  menu=we->FirstMenu;
  1767.  if(menu==NULL) return(NULL);
  1768.  if(menu->Menu.FirstItem==NULL) return(NULL);
  1769.  
  1770.  if(raw==FALSE)
  1771.   {
  1772.    ConvertToRawKey(code,&buffer);
  1773.    code=toupper(ConvertToVanillaKey(buffer[0],0));
  1774.    qualifier=buffer[1];
  1775.   }
  1776.  
  1777.  flags=0;
  1778.  if(qualifier & IEQUALIFIER_RALT) flags |= MICF_ALT;
  1779.  if(qualifier & IEQUALIFIER_LALT) flags |= MICF_ALT;
  1780.  if(qualifier & IEQUALIFIER_RCOMMAND) flags |= MICF_AMIGAR;
  1781.  if(qualifier & IEQUALIFIER_LCOMMAND) flags |= MICF_AMIGAL;
  1782.  if(qualifier & IEQUALIFIER_CONTROL) flags |= MICF_CTRL;
  1783.  if(qualifier & IEQUALIFIER_RSHIFT) flags |= MICF_SHIFT;
  1784.  if(qualifier & IEQUALIFIER_LSHIFT) flags |= MICF_SHIFT;
  1785.  if(raw)
  1786.   {
  1787.    if((code>=0x50)&&(code<=0x59))
  1788.     {
  1789.      flags |= MICF_FKEY;
  1790.      code-=0x50;
  1791.     }
  1792.    else if(code==0x5f)
  1793.     {
  1794.      flags |= MICF_HELP;
  1795.     }
  1796.    else
  1797.      return(NULL);
  1798.   }
  1799.  
  1800.  while(menu!=NULL)
  1801.   {
  1802.    item=menu->Menu.FirstItem;
  1803.    while(item!=NULL)
  1804.     {
  1805.      if((item->CommandKey==code)&&(item->CommandFlags==flags)) return(item);
  1806.      sub=item->MenuItem.SubItem;
  1807.      while(sub!=NULL)
  1808.       {
  1809.        if((sub->CommandKey==code)&&(sub->CommandFlags==flags)) return(sub);
  1810.        sub=sub->MenuItem.NextItem;
  1811.       }
  1812.      item=item->MenuItem.NextItem;
  1813.     }
  1814.    menu=menu->Menu.NextMenu;
  1815.   }
  1816.  
  1817.  return(NULL);
  1818. }
  1819.  
  1820. /* ---- Item-Aktion ausführen */
  1821. void CallItem(we,item)
  1822.  struct WindowEntry *we;
  1823.  struct MenuItem    *item;
  1824. {
  1825.  
  1826.  if((we->MenuOn)&&(!we->Iconify))
  1827.    ClearMenuStrip(we->Window);
  1828.  
  1829.  if(item->MenuItem.Flags & MENUTOGGLE)
  1830.   {
  1831.    if(item->MenuItem.Flags & CHECKED)
  1832.      item->MenuItem.Flags &= ~CHECKED;
  1833.    else
  1834.      item->MenuItem.Flags |= CHECKED;
  1835.   }
  1836.  else if(item->MenuItem.Flags & CHECKIT)
  1837.    item->MenuItem.Flags |= CHECKED;
  1838.  
  1839.  if(item->ItemAction) CallItemAction(we,item);
  1840.  
  1841.  if((we->MenuOn)&&(!we->Iconify))
  1842.    SetMenuStrip(we->Window,we->FirstMenu);
  1843. }
  1844.  
  1845. /* ---- ItemAction erstellen */
  1846. BOOL MakeItemAction(targetID,flags)
  1847.  ULONG targetID;
  1848.  UWORD flags;
  1849. {
  1850.  struct WindowEntry      *we;
  1851.  struct MWMenuItem       *item;
  1852.  struct ItemAction       *action;
  1853.  
  1854.  WE;
  1855.  if(we==NULL) return(FALSE);
  1856.  item=we->LastSubItem;
  1857.  if(item==NULL) item=we->LastMenuItem;
  1858.  if(item==NULL)
  1859.   {
  1860.    ErrorL(1123,"MakeItemAction():\nThere's no valid item or subitem!");
  1861.    return(FALSE);
  1862.   }
  1863.  
  1864.  action=AllocMemory(&item->Remember,sizeof(struct ItemAction),MEMF_PUBLIC);
  1865.  if(action==NULL)
  1866.   {
  1867.    NoMemory();
  1868.    return(FALSE);
  1869.   }
  1870.  
  1871.  action->TargetID=targetID;
  1872.  action->Flags=flags;
  1873.  action->NextItemAction=item->ItemAction;
  1874.  item->ItemAction=action;
  1875. }
  1876.  
  1877. /* ---- ItemAction-Liste entfernen */
  1878. void UnMakeItemAction(itemID)
  1879.  ULONG itemID;
  1880. {
  1881.  struct MWMenuItem *item;
  1882.  
  1883.  item=FindItemOrSubItem(itemID);
  1884.  if(item!=NULL)
  1885.   {
  1886.    item->ItemAction=NULL;
  1887.    FreeMemory(&item->Remember);
  1888.   }
  1889. }
  1890.  
  1891. /* ---- ItemAction ausführen */
  1892. void CallItemAction(we,item)
  1893.  struct WindowEntry *we;
  1894.  struct MWMenuItem  *item;
  1895. {
  1896.  struct ItemAction *action;
  1897.  struct MWMenuItem *target;
  1898.  UBYTE              windowID;
  1899.  
  1900.  windowID=ActWindow(we->WindowID);
  1901.  
  1902.  action=item->ItemAction;
  1903.  while(action!=NULL)
  1904.   {
  1905.    target=FindItemOrSubItem(action->TargetID);
  1906.    if(target!=NULL)
  1907.     {
  1908.      switch(action->Flags)
  1909.       {
  1910.        case IAF_UNCHECK:
  1911.          if(target->MenuItem.Flags & CHECKIT)
  1912.            target->MenuItem.Flags &= ~CHECKED;
  1913.         break;
  1914.        case IAF_CHECK:
  1915.          if(target->MenuItem.Flags & CHECKIT)
  1916.            target->MenuItem.Flags |= CHECKED;
  1917.         break;
  1918.        case IAF_DISABLE:
  1919.          target->MenuItem.Flags &= ~ITEMENABLED;
  1920.         break;
  1921.        case IAF_ENABLE:
  1922.          target->MenuItem.Flags |= ITEMENABLED;
  1923.         break;
  1924.       }
  1925.     }
  1926.    action=action->NextItemAction;
  1927.   }
  1928.  
  1929.  ActWindow(windowID);
  1930. }
  1931.  
  1932.